import BaseLayout from '@/layout/Base'
import SearchPanel from '@/components/SearchPanel'
import DataTable from '@/components/DataTable'
import Cookies from 'js-cookie'
import {getToken} from '@/utils/auth'
import {storageKey} from '@/utils/storageKey'
import {randomStr} from '@/utils/validate'
import store from '../store'
import { Loading } from 'element-ui'

//定时器
var interval = null;
//函数后缀
var func = "Func";
//构造函数
export default function ({
                           findDataById,//查询详情
                           findData,//分页函数
                           addData,//添加函数
                           updateData,//更新
                           deleteData,//删除 如果删除只删除当前表格数据 不保存后端则可以不处理
                           deleteDataRow,//删除行
                           dataName,//返回集合取值key
                           idName,//数据详情主键ID
                           format,//数据格式化处理，比如 status 转换由调用初始化页面实现
                           isAdd,// 表格中是否显示添加数据行
                           key,//业务存储key值由实现页面传入 全局唯一 命名时最好加入当前业务描述，从 storageKey文件中引入使用
                           refresh,//当前页面刷新路由
                           confirmData,//确认函数
                           auditData, //审核函数
                           findHistory,//查询历史
                           findHistoryKey,
                           updatePrintNum
                         }) {
  return {
    components: {BaseLayout, SearchPanel, DataTable},
    props: ['id'],
    data() {
      return {
        notQuery: false,
        searchOptions: {
          pageSize : 10,
          start : 1
        },
        pageSize: 10,
        start: 1,
        dialogTitle: '113',
        dialogVisible: false,
        tableData: [],
        dialogData: {},
        totalCount: 0,
        buttons: [],
        pageShow: false,
        key: key,
        findHistoryKey: findHistoryKey,
        showHistory: false,
        orderHistorys:[],//历史
        selectId:'',//历史
        loadingInstance:{},//loading
        headers: {'token': getToken()}//全局header
      }
    },
    /**
     * 初始化
     * @returns {Promise<void>}
     */
    async created() {
      this.initButtons();
      if (this.$store.state && this.$store.state.user && !this.$store.state.user.user) {
        this.$store.state.user.user = Cookies.getJSON('user') ? Cookies.getJSON('user').user : '';
      }
      if (!interval) {
        //20秒查询一次
      }
      //await this.setTableData()
      if(this.search){
        this.search();
      }
    },
    /**
     * 页面销毁清除定时器
     */
    destroyed() {
      clearInterval(interval);
      interval = null;
      console.log("destroyed:..",this)
    },
    activated(){
      // if(this.init){
      //   this.init();
      // }else{
      //   if(this.setTableData){
      //     this.setTableData()
      //   }
      // }
      // if(this.initHistory){
      //   //查询历史
      //   this.initHistory();
      // }

    },
    deactivated(){
    },
    /**
     * 函数体
     */
    methods: {
      loading(){
        // this.loadingInstance = Loading.service({
        //   lock: true,
        //   text: '拼命加载中....',
        //   spinner: 'el-icon-loading',
        //   background: 'rgba(0,0,0,0.2)'
        // });
        // //1分钟后自动关闭
        // setTimeout(() => {
        //   if(this.loadingInstance){
        //     this.loadingInstance.close();
        //   }
        // }, 1000 * 60 )
      },
      closeLoading(){
        // if(this.loadingInstance){
        //   this.loadingInstance.close();
        // }
      },
      /**
       * 分页查询
       * @returns {Promise<void>}
       */
      async setTableData() {
        this.loading();
        /*
        设置不默认查询，notQuery为true 手动查询修改notQuery为false
        */
        if (!this.notQuery) {
          if (findData) {

            this.searchOptions.pageSize = this.pageSize;
            this.searchOptions.start = this.start - 1;
            console.log("findData:",this.searchOptions)
            const res = await findData(this.searchOptions);
            if(Array.isArray(res.data)){
              //支持data数组
              this.totalCount = res.data.length;
              this.tableData = res.data;
            }else{
              if (!dataName || dataName[0] == '') {
                this.totalCount = res.data.totalCount;
                this.tableData = res.data.result;
                if(this.totalCount > 0 && this.tableData.length == 0 ){
                  this.start = 1;
                  this.setTableData();
                }
              } else {
                this.tableData =
                  format && Array.isArray(res[dataName[0]])
                    ? format(res[dataName[0]])
                    : res[dataName[0]]
                this.totalCount = res[dataName[1]]
              }
            }
            //数据查询成功后 页面正常渲染
            this.pageShow = true;
          }
        }
        if (isAdd) {
          this.tableData.unshift({ id: '', edit: true })
        }
        this.closeLoading();
        return this.tableData;
      },
      /**
       * 清除查询参数
       */
      clearSearchOptions() {
        this.searchOptions = {}
      },
      /**
       * 模态窗口关闭
       */
      dialogClose() {
        this.dialogVisible = false
        this.dialogTitle = '11'
        this.dialogData = {}
      },
      /**
       * 新增显示模态窗体
       */
      handleDataInsert(title) {
        if (title) {
          this.dialogTitle = title
        } else {
          this.dialogTitle = '新增';
          if(this.form){
            this.initNumber(this.form);
          }
        }
        this.dialogVisible = true
      },
      async handleDataUpdateVisible(row) {
        this.loading();
        // this.dialogData = row
        if(row && row.id){
          const detail = await findDataById(row.id);
          this.dialogData = detail
        }else{
          this.dialogData = row
        }
        this.consolePrint(this.dialogData)
        this.dialogTitle = '修改'
        this.dialogVisible = true
        this.closeLoading();
      },
      /**
       * 弹窗添加修改操作
       * @param data
       * @param operate
       * @returns {Promise<void>}
       */
      async handleDataOperate(data, operate) {
        this.loading();
        const { id } = operate === 'update' ? await updateData(data) : await addData(data)
        if (id ) {
          this.$message({
            message: '操作成功',
            type: 'success'
          })
          this.dialogClose()
          this.setTableData()
        } else {
        }
        this.closeLoading();
      },
      handleSend() {
        this.dialogTitle = '手动发送通知'
        this.dialogVisible = true
      },
      /**
       * 查看 row 列表行参数，path 跳转路径 ,keyObject state存放key
       * @param row
       * @param path
       * @param keyObject
       * @returns {Promise<void>}
       */
      async handleDataChange(row, path, keyObject) {
        this.loading();
        //先移除 清除旧数据
        sessionStorage.removeItem(keyObject);
        //总库首饰入库单 特殊处理
        sessionStorage.removeItem(storageKey.jewelryInParamList)
        //row 为空  undefined 表示新增
        if (row) {
          sessionStorage.setItem(keyObject, JSON.stringify(row));
          //跳转地址
          this.$router.push({path: path})
        } else {
          this.pageShow = true;
          //跳转地址
          this.$router.push({path: path});
        }
        this.closeLoading();
      },
      /**
       * 详情页回调函数 默认返回根据id查询的详情
       * @returns {Promise<null>}
       */
      async pageShowFunc(data,pageSize,currentPage) {
        this.loading();
        var result = null;
        const local = sessionStorage.getItem(this.key);
        let obj = null;
        if(local){
          obj = JSON.parse(local);
        }
        if(pageSize && currentPage){
          result = await findDataById(data,pageSize,currentPage)
        }else if (data) {
          data.id = obj[this.key]
          result = await findDataById(data)
        } else if (local && obj && obj[this.key]) {
          result = await findDataById(obj[this.key]);
        } else if (local && findDataById  && obj && obj[idName ? idName : "id"]) {
          result = await findDataById(obj[idName ? idName : "id"]);
        }
        if(result){
          this.consolePrint("pageShowFunc:"+ (result ? JSON.stringify(result) : '空数据'))
        }else{
          this.consolePrint(result)
        }

        //全局显示页面
        this.pageShow = true;
        this.closeLoading();
        //返回数据
        return result;
      },
      /**
       * 按指定路由刷新页面 否则取默认指定地址
       * @param router
       * @returns {Promise<void>}
       */
      async routerPage(router) {
        //router 表示跳转指定路由 否则跳转 refresh 路由
        if (router) {
          this.$router.push({path: router})
        } else if (refresh) {
          this.$router.push(refresh)
        } else {
          this.$message({
            message: '路由错误',
            type: 'error'
          })
        }
      },
      /**
       * 模态修改
       * @param row 修改的数据
       */
      handleDataAfferentChange(row) {
        this.dialogTitle = '修改'
        this.dialogVisible = true
        this.dialogData = row
      },
      /**
       * 更新或添加方法 函数从 basemixins构造传入 列表页面使用此方法 保存或新增成功后自动刷新列表数据
       *
       * @param 操作数据
       * @param operate 操作选项 默认新增 add  other update
       * @returns {Promise<void>}
       */
      async handleDataTableOperate(data, operate) {
        this.loading();
        const res = (data.id !== '' && typeof data.id !== 'undefined') ? await updateData(data) : await addData(data)
        if (res.id || res.success) {
          this.$message({
            message: '操作成功',
            type: 'success'
          })
          this.dialogClose()
          this.setTableData()
        }
        this.closeLoading();
      },
      /**
       *更新或添加方法 函数从 basemixins构造传入 二级详情页面使用此方法 次方法默认是新增 如需修改 第二个参数传入字符 update
       * 保存或新增成功后自动根据Id查询返回详情信息
       * @param data 数据
       * @param operate 操作
       * @param key key
       * @returns {Promise<void>}
       */
      async handleDataUpdate(data, operate, key) {
        this.loading();
        if (data && Object.prototype.toString.call(data) == '[object Object]') {
          // if(!data.items){
          //   this.$confirm('当前选择列表未选择数据, 是否继续?', '提示', {
          //     confirmButtonText: '确定',
          //     cancelButtonText: '取消',
          //     type: 'warning'
          //   })
          //     .then(async () => {
          //
          //     })
          //     .catch(() => {
          //
          //     })
          // }
          const res = data.id ? await updateData(data) : operate === 'update' ? await updateData(data) : await addData(data)
          this.closeLoading();
          if (res.id || res.success) {
            this.$message({
              message: '操作成功',
              type: 'success'
            })
            //当前id
            if (!sessionStorage.getItem(this.key) || !sessionStorage.getItem(this.key)[this.key]) {
              var obj = new Object();
              let key = this.key;
              obj[key] = res.id;
              sessionStorage.setItem(key, JSON.stringify(obj));
            }
            //如果为收入入库操作时需要特殊处理。清除首饰参数缓存
            sessionStorage.removeItem(storageKey.jewelryInParamList);
            if(this.$route.path == '/system/addUserInfo'){
              //用户添加页码特殊处理
              this.$store.dispatch('delVisitedViews', this.$route);
              this.routerPage(this.parentPage);
            }
            //如果是 // 'addUser' 用户管理特殊处理
            if(res.success || 'addUser'){
              this.$store.dispatch('delVisitedViews', this.$route);
              this.routerPage(this.parentPage);
            }else{
              //刷新当前页面  成功刷新一次
              this.reload();
            }
          } else {
            return res;
          }
        } else if(data) {
          this.$message({
            message: data ? data : "",
            type: 'error'
          });
        }
        this.closeLoading();

      },
      /**
       * 审核订单
       * @param key 详情存入本地key 必须
       * @param id 可为空 默认使用key查询存储数据 如果传入则用id
       * @returns {Promise<void>}
       */
      async handleAuditData(key, id) {
        this.$confirm('此操作将审核数据通过, 是否继续?', '提示', {
          confirmButtonText: '确定',
          cancelButtonText: '取消',
          type: 'warning',
          roundButton:true
        })
          .then(async () => {
            this.loading();
            const row = JSON.parse(sessionStorage.getItem(key ? key : this.key));
            if(row == null){
              this.showMsg("请先保存订单","error")
              return ;
            }
            const {success} = await auditData(id ? id : row[this.key] ?  row[this.key] : row[idName])
            this.closeLoading();
            if (success) {
              this.$message({
                message: '审核成功',
                type: 'success'
              })
              //关闭当前页面 返回首页
              this.$store.dispatch('delVisitedViews', this.$route);
              this.routerPage(this.parentPage);
            } else {
              return row;
            }
          })
          .catch(() => {
            // this.$message({
            //   type: 'info',
            //   message: '失败'
            // })
          })
      },
      /**
       * 列表确认订单
       * @param key 详情存入本地key 必须
       * @param id 可为空 默认使用key查询存储数据 如果传入则用id
       * @returns {Promise<void>}
       */
      async handleConfirmTableData(row) {
        this.$confirm('此操作将确认数据无误, 是否继续?', '提示', {
          confirmButtonText: '确定',
          cancelButtonText: '取消',
          type: 'warning',
          roundButton:true
        })
          .then(async() => {
            const { success } = await confirmData(row[this.key] ?  row[this.key] : row[idName])
            if (success) {
              this.$message({
                message: '确认成功',
                type: 'success'
              })
              // 刷新当前页面
              this.setTableData()
            } else {
              return row
            }
          })
          .catch(() => {})
      },
      /**
       * 确认订单
       * @param key 详情存入本地key 必须
       * @param id 可为空 默认使用key查询存储数据 如果传入则用id
       * @returns {Promise<void>}
       */
      async handleConfirmData(key, id) {
        this.$confirm('此操作将确认数据无误, 是否继续?', '提示', {
          confirmButtonText: '确定',
          cancelButtonText: '取消',
          type: 'warning',
          roundButton:true
        })
          .then(async () => {
            const row = JSON.parse(sessionStorage.getItem(key ? key : this.key));
            if(row == null){
              this.showMsg("请先保存订单","error")
              return ;
            }
            const {success} = await confirmData(id ? id : row[this.key] ?  row[this.key] : row[idName])
            if (success) {
              this.$message({
                message: '确认成功',
                type: 'success'
              })
              //关闭当前页面 返回首页
              this.$store.dispatch('delVisitedViews', this.$route);
              this.routerPage(this.parentPage);
            } else {
              return row;
            }
          })
          .catch(() => {})
      },
      /**
       * 详情删除
       * @param row
       * @returns {Promise<void>}
       */
      async handleDataDelete(key, id) {
        this.$confirm('此操作将永久删除该数据, 是否继续?', '提示', {
          confirmButtonText: '确定',
          cancelButtonText: '取消',
          type: 'warning',
          roundButton:true
        })
          .then(async () => {
            const row = key && key[idName] ? key : JSON.parse(sessionStorage.getItem(key ? key : this.key));
            if(row == null){
              this.showMsg("请先保存订单","error")
              return ;
            }

            const {success} = await deleteData(id ? id : row[this.key] ?  row[this.key] : row[idName]);

            if (success) {
              this.$message({
                message: '删除成功',
                type: 'success'
              })
              if(this.parentPage){
                //关闭当前页面 返回首页
                this.$store.dispatch('delVisitedViews', this.$route);
                this.routerPage(this.parentPage);
              }else{
                this.reload()
              }
            } else {
              return row;
            }
          })
          .catch((e) => {
           console.log(e)
          })
      },
      /**
       * 列表删除函数 删除后自动刷新列表数据
       * @param row 要删除的数据对象
       * @returns {Promise<void>}
       */
      async handleDataTableDelete(row) {
        this.$confirm('此操作将永久删除该数据, 是否继续?', '提示', {
          confirmButtonText: '确定',
          cancelButtonText: '取消',
          type: 'warning',
          roundButton:true
        })
          .then(async () => {
            const {success} = await deleteData(row[this.key] ?  row[this.key] : row[idName])
            if (success) {
              this.$message({
                message: '删除成功',
                type: 'success'
              })
              //刷新当前数据
              this.setTableData()
            } else {
              this.$message({
                message: '删除失败',
                type: 'error'
              });
            }
          })
          .catch(() => {})
      },
      async deletedRowtable(row) {
        this.$confirm('此操作将永久删除该数据, 是否继续?', '提示', {
          confirmButtonText: '确定',
          cancelButtonText: '取消',
          type: 'warning',
          roundButton:true
        })
          .then(async () => {
            const {code,message,data} = await deleteDataRow(row)
            if (code == "0") {
              this.$message({
                message: message,
                type: 'success'
              })
              //刷新当前数据
              this.setTableData()
            } else {
              this.$message({
                message: message,
                type: 'error'
              });
            }
          })
          .catch(() => {})
      },
      /**
       * 本地删除首饰列表行方法
       * @param row
       */
      async deletedRow(row) {

        this.$confirm('此操作将删除该数据, 是否继续?', '提示', {
          confirmButtonText: '确定',
          cancelButtonText: '取消',
          type: 'warning',
          roundButton:true
        })
          .then(async () => {
            this.filters.items.forEach((value, index, arr) => {
              if (value.id === row.id) {
                value.deleted = true
                value.addType = 'delete';
                return;
              }
            })
          })
          .catch(() => {
          })
      },
      /**
       * 关闭当前页面 返回上一级页面
       * @param router 可选 默认不做任何操作  可跳转指定页面 也可以返回上级
       * @returns {Promise<void>}
       */
      async closePage(router) {
        //关闭当前页面 返回首页
        this.$store.dispatch('delVisitedViews', this.$route);
        if (router) {
          this.routerPage(router);
        } else if (this.parentPage) {
          this.routerPage(this.parentPage);
        }
      },
      /**
       * 需要提示的消息
       * @param msg 提示消息
       * @param type 默认 info 可选 success info error
       * @returns {Promise<void>}
       */
      async showMsg(msg, type) {
        this.$message({
          type: type ? type : 'info',
          message: msg
        })
        this.closeLoading();
      },
      /**
       *
       * @param printId 打印dom id
       * @param auto 是否直接打印 默认为 false 注意特殊字符
       * @param init 任务名称
       * @param title 可选标题 一般打印页自定义w
       */
      printDom(printId,row, auto, init, title,topMargin,setPageSize) {
        let LODOP = getLodop();
        //打印回调  i > 0 表示打印次数
        LODOP.On_Return = async function (item, i) {
          console.log("print_result:" + item)
          if (i > 0) {
            const row = JSON.parse(sessionStorage.getItem(key ? key : this.key));
            //有id 则打印成功后更新打印次数
            if (row) {
              const {success} = await updatePrintNum(row[idName]);
              console.log("print result:" + success)
            }
          }
        };
        //初始化打印任务名
        LODOP.PRINT_INIT(init ? init : randomStr());
        //默认设置大小
        if(!setPageSize){
          LODOP.SET_PRINT_PAGESIZE(1,2420,1270,"");
        }
        LODOP.SET_PRINT_STYLE("FontSize", 18);
        LODOP.SET_PRINT_STYLE("Bold", 0);

        let htmlBody =  "<body>"+document.getElementById(printId).innerHTML +"</body>";
        //console.log(htmlBody)
        //25上边距 销售小票需要25间距 不要修改。或者替换为动态
        LODOP.ADD_PRINT_HTM(topMargin ? topMargin : 2, 0, '100%', '100%', htmlBody);
        //AUTO_CLOSE_PREWINDOW 打印完成后自动关闭窗口
        LODOP.SET_PRINT_MODE('AUTO_CLOSE_PREWINDOW', true);
        if (auto) {
          LODOP.PRINT();
        } else {
          //设置预览窗口大小
          LODOP.SET_PREVIEW_WINDOW(1, 2, 0, 1024, 666, '自定义标题.开始打印');
          LODOP.PREVIEW();
        }
      },
      /**
       * 统一日志输出
       * @param obj
       */
      consolePrint(obj) {
        if (Object.prototype.toString.call(obj) == '[object Object]') {
          console.error("object_print:" + JSON.stringify(obj));
        } else if (Object.prototype.toString.call(obj) == '[object Array]') {
          console.error("Array_print:" + JSON.stringify(obj));
        } else if (Object.prototype.toString.call(obj) == '[object Function]') {
          console.error("Function_print:" + obj);
        } else {
          console.error("print:" + obj);
        }
      },
      /**
       * 分页函数
       * @param pageSize
       */
      handleSizeChange(pageSize) {
        this.pageSize = pageSize
        this.setTableData()
        //TODO 待实现详情页面查询列表
        this.consolePrint("pageSize:"+pageSize)
      },
      /**
       * 分页
       * @param currentPage
       */
      handleCurrentChange(currentPage) {
        this.start = currentPage
        this.setTableData()
        this.consolePrint("start:"+currentPage)
      },

      async handleDataTableChange(row, send) {
        const res = await findDataById(row[idName])
        if (send) {
          this.dialogTitle = send
        } else {
          this.dialogTitle = '查看'
        }
        this.dialogVisible = true
        this.dialogData = res
      },
      async searchHistory(history){
        if(history && history.id){
          const result = await findHistory(history.id);
          if(result && result.length > 0){
            console.log("findHistory:",this.findHistoryKey)
            //使用函数名称作为key
            sessionStorage.setItem(this.findHistoryKey, JSON.stringify(result));
            this.routerPage(this.historyPage);
          }
        }
      },
      historyChange(value) {
        const res = this.orderHistorys.find(or =>(or.id == value));
        if(res){
          //兼容 form  filters
          if(this.form){
            res.items = this.formatBranch(res.items);
            this.form = res;
          }else{
            res.items = this.formatBranch(res.items);
            this.filters = res;
          }
        }
      },
      /**
       * 处理
       */
      formatBranch(res) {
        return res.map(data => {
          if( data.costPrice && data.quantity){
            data.costSumPrice = data.costPrice * data.quantity;
          }else{
            data.costSumPrice = 0;
          }
          if( data.salePrice && data.quantity){
            data.saleSumPrice = data.salePrice * data.quantity;
          }else{
            data.saleSumPrice = 0;
          }
          data.source = this.source;
          return data
        })
      },
      /**
       * 初始化按钮权限
       */
      initButtons(){
        if(this.buttons){
          //管理员默认显示按钮
          if(sessionStorage.getItem("SET_FRANCHISEE_ADMIN") == "true"){
            for(var button in this.buttons){
              this.buttons[button] = true;
            }
          }else{
            const keys = [];
            for(var button in this.buttons){
              keys.push(button);
            }
            // const buttonsUser = store.getters.userRouters.filter(item => {return item.type == 2})
            // buttonsUser.forEach(button => {
            //   const but = keys.find( key => { return key == button.path});
            //   if(but){
            //     this.buttons[but] = true;
            //   }else{
            //     //console.log("error_button:",button)
            //   }
            // })
          }
        }
      },
      //初始化统计数据为0
      initNumber(obj){
        if(obj){
          for(var key in obj){
            try{
              if(typeof obj[key] == "number"){
                obj[key] = 0;
              }else if(typeof obj[key] == "string"){
                obj[key] = "";
              }
            }catch (error) {
              console.log(error)
            }
          }
        }
      },
      resultApply(datas,tempQuery){
        let { message, code, data } = datas;
        if (code !== "0") {
          this.showMsg(message,"error");
        }
        this.dialogVisible = false;
        if(this.search){
          this.search();
        }
      },
      resultSuccess(datas){
        let { message, code, data } = datas;
        if (code == "0") {
          this.showMsg(message,"success");
        }
        this.dialogVisible = false;
        if(this.search){
          this.search();
        }
      },
      editRow(row){
        this.dialogTitle = "编辑";
        this.dialogVisible = true;
        //通道类型
        if(row && row.operatorsBase && row.operatorsBase.operatoruid ){
          row.operatoruid = row.operatorsBase.operatoruid;
        }
        this.form = row;
      },
      //两数相加
      numAdd(num1, num2) {
        var baseNum, baseNum1, baseNum2;
        try {
          baseNum1 = num1.toString().split(".")[1].length;
        } catch (e) {
          baseNum1 = 0;
        }
        try {
          baseNum2 = num2.toString().split(".")[1].length;
        } catch (e) {
          baseNum2 = 0;
        }
        baseNum = Math.pow(10, Math.max(baseNum1, baseNum2));
        return (num1 * baseNum + num2 * baseNum) / baseNum;
      },
      //减
      numSubtraction(num1, num2) {
        var baseNum, baseNum1, baseNum2;
        try {
          baseNum1 = num1.toString().split(".")[1].length;
        } catch (e) {
          baseNum1 = 0;
        }
        try {
          baseNum2 = num2.toString().split(".")[1].length;
        } catch (e) {
          baseNum2 = 0;
        }
        baseNum = Math.pow(10, Math.max(baseNum1, baseNum2));
        return (num1 * baseNum - num2 * baseNum) / baseNum;
      },

    }
  }
}


//获取函数名称
Function.prototype.getName = function(){
  return this.name || this.toString().match(/function\s*([^(]*)\(/)[1]
}
